The present invention relates to the field of computers. More specifically, the present invention relates to resource management.
Software engineering considerations, data protection, multi-vendor development, the availability of extensible execution environments, and other factors have been causing a shift in software development from large, monolithic applications to application component federations. To date, most research and commercial operating systems work has focused on managing resources available to a single application only, or to a group of applications connected by the parent-child relationship. Increasingly, there is a need for mechanisms that enable defining resource policies applicable to arbitrarily grouped collections of components.
For instance, enterprise applications are increasingly being built using type-safe programming platforms and deployed over horizontally scalable systems. Crucial to horizontal scalability is the ability to monitor resource usage and to define and enforce resource management policies capable of guaranteeing a desired service level. However, current safe language platforms have very limited support for resource management, and their cluster-enabled versions reflect this deficiency. The end result is that resource management capabilities typically reduce to coarse grained management of a single resource.
Cluster computing aims at capturing the promise of horizontal scalability offered by interconnected computers. Safe languages, in conjunction with their associated component architectures, such as the Java 2 Enterprise Environment (J2EE®) architecture and .NET's managed components, address the problem of the development of portable, multi-component applications. Numerous designs of the Java Virtual Machine (JVM®) virtual machine enhanced for cluster computing reflect the importance of both safe language platforms and clusters of computers. However, all of these system designs have at least one of the following shortcomings: (i) lack of a well-defined container mechanism with guarantees strong enough to enable effective performance isolation for cluster applications, (ii) only coarse grain of resource management (e.g., in the case of the processing time, granularities often are the number of processors, computers, or whole-machine load), (iii) only mono-resource management (typically only processing time), and/or (iv) ability to monitor only, without control exercising capabilities. To a large extent, these deficiencies follow from weak support for resource management, especially for defining and enforcing resource consumption policies, in the Java platform. However, the deficiencies are also present in many cluster programming environments not based on safe languages.
Although some of these deficiencies may not seem substantial in current applications, failing to address the shortcomings ignores trends in computing. Coarse granularity may be sufficient in specialized settings (e.g., long-running, processor-intensive tasks), but leads to inefficiencies when considered in conjunction with a trend toward applications consisting of a dynamic population of components that vary in their resource needs and lifetimes. Resource management oriented towards controlling processor usage is applicable to processor-bound applications, but is inadequate in situations where using network, databases, or memory dominates. Overall, current cluster programming systems based on safe languages offer scant information on resource consumption and only rudimentary mechanisms for controlling a small set of resources. These limitations constrain what can be done with respect to load-balancing and service provisioning. As clusters of computers become a more significant part of the modern computing landscape, the need for resource management policy defining mechanisms that apply equally well to both a single computer and clusters of computers becomes more prominent.